// General problem: how to use symbol resolution tables to shorten symbol resolution paths. How context information suffices to resolve a symbol.
// Let Symbol=signifier=referer, symbolized object=significant=referee. General problem: how to regard at several signifiers on the same significant.
import F;
import static F.f;
class references {
	D d;
	A spring_A(Obj o) {...}
	foo() {
		A a;   // Type Symbol A
		a = spring_A();  // spring_A is in scope, lexically foward (the backward version is prototype incompatible)
		B b;  // Symbolic Type B
		C c;
		c = b.get();  // Invocation on a symbolic type B. get method needs a prototype with a return type compatible with C.
		d = null;   // d is in scope
		e = null;   // e is in scope, lexically foward
		f = null;  // f is in scope
		A a2;   // Already symbol-resolved Type A
		f.get().get2();  // Invocation on return type of get method.
		f.get().get2() + d.get();   // Involving expressions
		d.set(e);   // Involving expressions
		F.f = null;  // F.f is in scope, the signifier is f, indeed.
	}
	E e;
	A spring_A() {...}
}
